home *** CD-ROM | disk | FTP | other *** search
/ Speccy ClassiX 1998 / Speccy ClassiX 98.iso / amiga_system / the_aminet / dev / gcc / ixemulsrc.lha / ixemul-41.4 / library / vfork.c < prev    next >
C/C++ Source or Header  |  1995-09-27  |  20KB  |  643 lines
  1. /*
  2.  *  This file is part of ixemul.library for the Amiga.
  3.  *  Copyright (C) 1991, 1992  Markus M. Wild
  4.  *  Portions Copyright (C) 1994 Rafael W. Luebbert
  5.  *
  6.  *  This library is free software; you can redistribute it and/or
  7.  *  modify it under the terms of the GNU Library General Public
  8.  *  License as published by the Free Software Foundation; either
  9.  *  version 2 of the License, or (at your option) any later version.
  10.  *
  11.  *  This library is distributed in the hope that it will be useful,
  12.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.  *  Library General Public License for more details.
  15.  *
  16.  *  You should have received a copy of the GNU Library General Public
  17.  *  License along with this library; if not, write to the Free
  18.  *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  *
  20.  *  $Id: vfork.c,v 1.9 1994/06/19 15:18:29 rluebbert Exp $
  21.  *
  22.  *  $Log: vfork.c,v $
  23.  *  Revision 1.9  1994/06/19  15:18:29  rluebbert
  24.  *  *** empty log message ***
  25.  *
  26.  *  Revision 1.7  1992/10/20  16:29:49  mwild
  27.  *  allow a vfork'd process to use the parents memory pool. The new function
  28.  *  vfork2() continues to use the old semantics.
  29.  *
  30.  *  Revision 1.6  1992/09/14  01:48:11  mwild
  31.  *  move kmalloc() out of Forbid() (since the allocator is now Semaphore-based).
  32.  *  move errno assignment after sigsetmask (thanks Niklas!)
  33.  *  remove dead code
  34.  *
  35.  *  Revision 1.5  1992/08/09  21:01:43  amiga
  36.  *  change to 2.x header files
  37.  *  duplicate calling stack frame in vfork_resume() instead of just doing rts.
  38.  *  temporary abort calling 1.3 vfork, until that's fixed again (when???).
  39.  *
  40.  *  Revision 1.4  1992/07/04  19:24:12  mwild
  41.  *  get passing of environment right.
  42.  *  change ix_sleep() calls to new semantics.
  43.  *
  44.  * Revision 1.3  1992/05/18  12:26:25  mwild
  45.  * fixed bad typo that didn't close files before sending wait message.
  46.  * Set childs Input()/Output() to NIL:, we only keep the files in our
  47.  * own filetable.
  48.  *
  49.  * Revision 1.2  1992/05/18  01:02:31  mwild
  50.  * add temporary Delay(100) before CloseLibrary() in the child after
  51.  * vfork(), there seem to arrive some late packets (don't know why..)
  52.  * pass NIL: filehandles as Input()/Output() to the child, so that the
  53.  * real I/O-handles only depend on ix-filetable for usage-count
  54.  *
  55.  * Revision 1.1  1992/05/14  19:55:40  mwild
  56.  * Initial revision
  57.  *
  58.  */
  59.  
  60. #define KERNEL
  61. #include "ixemul.h"
  62. #include "kprintf.h"
  63.  
  64. #include <sys/syscall.h>
  65. #include <sys/resource.h>
  66. #include <sys/wait.h>
  67. #include <stddef.h>
  68. #include <setjmp.h>
  69.  
  70. void vfork_own_malloc ();
  71. void volatile vfork_longjmp (jmp_buf, int);
  72. extern char **dupvec (char **);
  73.  
  74. #include <utility/tagitem.h>
  75. #include <dos/dostags.h>
  76.  
  77. /* having it in a struct makes parameter passing easier */
  78.  
  79. struct reg_parms {
  80.   jmp_buf jb;
  81. };
  82.  
  83. struct vfork_msg {
  84.   struct Message     vm_msg;
  85.   struct Process    *vm_self;    /* for validation purposes (1.3, grrr) */
  86.   struct Process     *vm_pptr;
  87.   struct reg_parms     *vm_regs;    /* parents context to restore */
  88.   int            vm_own_malloc;
  89.   int             vm_rc;        /* 0 if the child started normally, else errno */
  90. };
  91.  
  92. struct death_msg {
  93.   struct MinNode    dm_node;
  94.   struct Process    *dm_child;
  95.   int            dm_pgrp;
  96.   int            dm_status;
  97.   struct rusage        dm_rusage;
  98. };
  99.  
  100. /* this is the new process generated by vfork () ! */
  101. static void
  102. launcher ()
  103. {
  104.   void *ixb = OpenLibrary ("ixemul.library", IX_VERSION);
  105.   struct Process *me = (struct Process *) FindTask (0);
  106.   struct vfork_msg *vm;
  107.   int omask;
  108.  
  109.   /* the launcher() generated by Arp's ASyncRun seems to get a weird
  110.      message. Verify that the message at least looks right.. (damn 1.3 support..) */
  111.   vm = 0;
  112.   do
  113.     {
  114.       if (! vm) 
  115.         WaitPort (& me->pr_MsgPort);
  116.       vm = (struct vfork_msg *) GetMsg (& me->pr_MsgPort);
  117.     }
  118.   while (vm->vm_self != me);
  119.       
  120.  
  121.   if (ixb)
  122.     {
  123.       /* get parents user area */
  124.       volatile struct user *pu = (struct user *) (vm->vm_pptr->pr_Task.tc_TrapData);
  125.       /* `my' user area. This way we don't have to recalculate it too often */
  126.       volatile struct user *mu = &u;
  127.       /* reaping the dup function of execve() ;-)) */
  128.       int fd, rc;
  129.  
  130.       /* link ourselves into the parents process lists. Guarantee single
  131.        * threaded access to those lists by locking out any other users of
  132.        * the library (nicer than to just call Forbid()) */
  133.       ix_lock_base ();
  134.       
  135.       /* our older sybling is the last recently created child of the parent */
  136.       mu->p_osptr = pu->p_cptr;
  137.       /* we have no younger sybling */
  138.       mu->p_ysptr = 0;
  139.       /* if we have an older sybling, point its `younger sybling' field at us */
  140.       if (mu->p_osptr)
  141.         {
  142.           struct user *ou = (struct user *) (mu->p_osptr->pr_Task.tc_TrapData);
  143.       ou->p_ysptr = me;
  144.     }
  145.       /* set the parents `last recently created child' field at us */
  146.       pu->p_cptr = me;
  147.  
  148.       /* inherit the process group of our parent */
  149.       mu->p_pgrp = pu->p_pgrp;
  150.       mu->p_pptr = vm->vm_pptr;
  151.  
  152.       /* if we got our own malloc list already, it is save to call malloc here.
  153.          If not, the stuff done here is postponed to either vfork_resume, or
  154.          execve */
  155.       if (vm->vm_own_malloc)
  156.     {
  157.       /* inherit these global variables. */
  158.       mu->u_environ = (char ***) malloc (4);
  159.       * mu->u_environ = dupvec (* pu->u_environ);
  160.       mu->u_errno   = (int *) malloc (4);
  161.       *mu->u_errno = 0;
  162.     }
  163.       else
  164.     {
  165.       /* borrow the variables of the parent */
  166.       mu->u_environ = pu->u_environ;
  167.       mu->u_errno = pu->u_errno;
  168.       
  169.       /* tell malloc to use the parents malloc lists */
  170.       mu->u_mdp = pu->u_mdp;
  171.     }
  172.  
  173.       
  174.       /* and inherit several other things as well, upto not including u_md */
  175.       bcopy (& pu->u_signal[0], & mu->u_signal[0],
  176.          offsetof (struct user, u_md) - offsetof (struct user, u_signal[0]));
  177.  
  178.       /* some things have been copied that should be reset */      
  179.       mu->p_flag &= ~SFREEA4;
  180.       bzero (& mu->u_ru, sizeof (struct rusage));
  181.       bzero (& mu->u_cru, sizeof (struct rusage));
  182.       bzero (& mu->u_timer[0], sizeof (struct itimerval)); /* just the REAL timer! */
  183.       syscall (SYS_gettimeofday, & mu->u_start, 0);
  184.       omask = vm->vm_rc;    /* signal mask to restore at the end */
  185.  
  186.       /* and adjust the open count of each of the copied filedescriptors */
  187.       for (fd = 0; fd < NOFILE; fd++)
  188.         if (mu->u_ofile[fd])
  189.           mu->u_ofile[fd]->f_count++;
  190.  
  191.       /* copying finished, allow other processes to vfork() as well ;-)) */
  192.       ix_unlock_base ();
  193.       
  194.       /* remember the message we have to reply when either _exit() or 
  195.        * execve() is called */
  196.       mu->p_vfork_msg = vm;
  197.       
  198.       vm->vm_rc = 0;
  199.  
  200.       mu->u_save_sp = (void *) get_sp ();
  201.  
  202.       /* we get here when the user does an _exit() 
  203.        * (so as well after execve() terminates !) */
  204.       if (rc = _setjmp (mu->u_jmp_buf))
  205.         {
  206.       struct death_msg *dm = 0;
  207.       int i, errno_dummy;
  208.  
  209.       /* overkill? */
  210.       vfork_own_malloc ();
  211.  
  212.       /* reset `mu' in here, setjmp() might have clobbered it */
  213.       mu = &u;
  214.  
  215.       /* although this is done in CloseLibrary(), files should 
  216.          really be closed *before* a death-message is sent to
  217.          the parent. */
  218.       for (i = 0; i < NOFILE; i++) 
  219.         if (u.u_ofile[i]) syscall (SYS_close, i);
  220.  
  221.       /* free memory (look that most, best all memory is freed here, as
  222.              long as we're not inside Forbid. If memory is freed in CloseLibrary,
  223.          it may potentially have to wait for the memory semaphore in buddy-alloc.c,
  224.          thus breaking the Forbid! */
  225.       all_free ();
  226.  
  227.           /* Since errno (= *u.u_errno) is still used by ix_sleep we point it
  228.              to our own temporary errno dummy variable */
  229.           u.u_errno = &errno_dummy;
  230.       KPRINTF (("&errno = %lx, errno = %ld\n", &errno, errno));
  231.  
  232.       /* KPRINTF (("vforked: _exit in progress, rc = %ld.\n", rc)); */
  233.  
  234.       /* this whole thing only happens if our parent is still alive ! */
  235.       if (mu->p_pptr && mu->p_pptr != (struct Process *) 1)
  236.         {
  237.           rc --;
  238.  
  239.           /* KPRINTF (("vforked: parent alive, zombie-sig = %ld, vfork_msg = $%lx.\n",
  240.          pu->p_zombie_sig, mu->p_vfork_msg));*/
  241.  
  242.           pu = (struct user *) (mu->p_pptr->pr_Task.tc_TrapData);
  243.  
  244.           /* send the parent a death message with our return code */
  245.           dm = (struct death_msg *) kmalloc (sizeof (struct death_msg));
  246.  
  247.           Forbid ();
  248.           if (dm)
  249.         {
  250.           dm->dm_status = (rc >= 128) ? W_EXITCODE (0, rc & 0x7f) 
  251.                       : W_EXITCODE (rc, 0);
  252.           dm->dm_rusage = mu->u_ru;
  253.           ruadd (&dm->dm_rusage, &mu->u_cru);
  254.           dm->dm_child = (struct Process *) FindTask (0);
  255.           dm->dm_pgrp  = mu->p_pgrp;
  256.           KPRINTF (("vfork-exit: Adding child $%lx to $%lx\n", dm->dm_child, mu->p_pptr));
  257.           AddTail ((struct List *) &pu->p_zombies, (struct Node *) dm);
  258.         }
  259.  
  260.           _psignal (mu->p_pptr, SIGCHLD);
  261.  
  262.           /* have to wakeup the parent `by hand' to make sure it gets
  263.              out of its sleep, since it might have SIGCHLD masked out or
  264.              ignored at the moment */
  265.           if (pu->p_stat == SSLEEP && pu->p_wchan == (caddr_t) pu)
  266.         ix_wakeup (pu);
  267.  
  268.           if (mu->p_vfork_msg)
  269.             ReplyMsg ((struct Message *) mu->p_vfork_msg);
  270.  
  271.           /* KPRINTF (("vforked: unlinking from parent process chains\n"));*/
  272.           /* unlink us from the parents process chains */
  273.  
  274.           if (mu->p_ysptr)
  275.             {
  276.               struct user *yu = (struct user *) (mu->p_ysptr->pr_Task.tc_TrapData);
  277.               yu->p_osptr = mu->p_osptr;
  278.             }
  279.  
  280.           if (mu->p_osptr)
  281.             {
  282.              struct user *ou = (struct user *) (mu->p_osptr->pr_Task.tc_TrapData);
  283.              ou->p_ysptr = mu->p_ysptr;
  284.             }
  285.  
  286.           if (pu->p_cptr == me)
  287.             pu->p_cptr = mu->p_osptr;
  288.  
  289.           /* moved this code into the if-block, as it should only be 
  290.              executed if there really is a parent that might wait for the
  291.              child to terminate (ignore that `this can't happen', perhaps
  292.              it does... */
  293.  
  294.           /* this seems to be necessary for process synchronisation, or
  295.              else it is possible that the same process address is
  296.              reused before the parent noticed the death of this child,
  297.              and this would rather confuse it (or ksh at least ;-)) */
  298.           if (dm)
  299.             ix_sleep (dm, "vfork-dm");
  300.         }
  301.       else
  302.         {
  303.           Forbid ();
  304.           KPRINTF (("vforked: couldn't send death_msg\n"));
  305.         }
  306.  
  307.       KPRINTF (("vforked: now closing library\n"));
  308.  
  309.       /* temporary `fix'.. there seem to be some packets arriving
  310.          too late.. */
  311.       Delay (100);
  312.  
  313.       CloseLibrary (ixb);
  314.  
  315.       KPRINTF (("vforked: falling off the edge of the world.\n"));
  316.       /* just fall off the edge of the world, this is a process */
  317.       return;
  318.         }
  319.  
  320.       syscall (SYS_sigsetmask, omask);
  321.  
  322.       KPRINTF (("vforked: jumping back\n"));
  323.  
  324.       /* jump into nevereverland ;-) */
  325.       vfork_longjmp (vm->vm_regs->jb, 0);
  326.       /* NOTREACHED */
  327.     }
  328.  
  329.   vm->vm_rc = ENOMEM; /* can't imagine any other reason why the OpenLib should fail */
  330.   ReplyMsg ((struct Message *) vm);
  331.   /* fall off the edge of the world ;-) */
  332. }
  333.  
  334.  
  335. /* This function is used by vfork_resume and execve. Perhaps it should be made
  336.    externally available? It causes the process to switch to its own malloc
  337.    list, and copies errno and environ into private space. */
  338. void
  339. vfork_own_malloc (void)
  340. {
  341.   /* use volatile here, or the compiler might do wrong `optimization' .. */
  342.   volatile struct user *p = &u;
  343.  
  344.   if (p->u_mdp != &p->u_md)
  345.     {
  346.       char **parent_environ = * p->u_environ;
  347.       
  348.       /* switch to our memory list (which is initialized by OpenLibrary) */
  349.       p->u_mdp = &p->u_md;
  350.       /* dupvec now uses malloc() on our list */
  351.       p->u_environ = (char ***) malloc (4);
  352.       *p->u_environ = dupvec (parent_environ);
  353.     }
  354. }
  355.  
  356.  
  357. /*
  358.  * this is an implementation extension to the `real' vfork2(). Normally you
  359.  * can only cause the parent to resume by calling _exit() or execve() from
  360.  * the child. Since I can't provide a real fork() on the Amiga, this function
  361.  * is a third possibility to make the parent resume. You have then two
  362.  * concurrent processes sharing the same frame and global data... Please be
  363.  * EXTREMELY careful what you may do and what not. vfork2() itself is a hack,
  364.  * this is an even greater one...
  365.  *
  366.  * DO NOT use this function in combination with vfork(), or you'll get a big
  367.  * memory leak. Only use it with vfork2().
  368.  *
  369.  * Note that this function should really be static, but if you make it static
  370.  * and compile it with "gcc -O4", it appears to go away completely.  This may
  371.  * be a bug in gcc 2.6.3 or it may not, but making it global works around
  372.  * the problem for now.  This should be tracked down and either the gcc
  373.  * bug fixed, or the makefile changed to treat vfork specially.  FIXME-fnf
  374.  *
  375.  */
  376.  
  377. /* static */ void
  378. _vfork_resume (u_int *copy_from_sp)
  379. {
  380.   struct vfork_msg **vm = &u.p_vfork_msg;
  381.  
  382.   if (*vm)
  383.     {
  384.       u_int *sp = (u_int *)u.u_save_sp;
  385.       u_int *copy_till_sp = (u_int *)get_sp ();
  386.  
  387.       /* be sure to switch to our memory list */
  388.       vfork_own_malloc ();
  389.  
  390.       /* copy the stack frame */
  391.       copy_from_sp++;
  392.       do
  393.     *--sp = *--copy_from_sp;
  394.       while (copy_from_sp > copy_till_sp);
  395.  
  396.       set_sp ((u_int) sp);
  397.  
  398.       ReplyMsg ((struct Message *) *vm);
  399.       *vm = 0;
  400.     }
  401. }
  402.  
  403.  
  404. asm ("
  405.     .globl _vfork
  406.     .globl _vfork2
  407.     .globl _vfork_resume
  408. _vfork:
  409.     | store a setjmp () compatible frame on the stack to pass to _vfork ()
  410.     lea    sp@(-18*4),sp        | _JBLEN (17) longs on the stack
  411.     pea    sp@
  412.     jbsr    _setjmp
  413.     lea    sp@(4),sp
  414.     | now patch sp and pc, since they differ
  415.     addl    #20*4,sp@(8)        | account for buffer space
  416.     movel    sp@(18*4),sp@(20)    | insert real PC (return addr on stack)
  417.     | tell _vfork *not* yet to switch to own malloc-list
  418.     pea    0
  419.     bsr    __vfork
  420.     lea    sp@(18*4 + 4),sp
  421.     rts
  422.  
  423. _vfork2:
  424.     | this is the vfork used in older versions of the library
  425.     lea    sp@(-18*4),sp        | _JBLEN (17) longs on the stack
  426.     pea    sp@
  427.     jbsr    _setjmp
  428.     lea    sp@(4),sp
  429.     | now patch sp and pc, since they differ
  430.     addl    #20*4,sp@(8)        | account for buffer space
  431.     movel    sp@(18*4),sp@(20)    | insert real PC (return addr on stack)
  432.     | tell _vfork to have the child run with own malloc-list.
  433.     pea    1
  434.     bsr    __vfork
  435.     lea    sp@(18*4 + 4),sp
  436.     rts
  437.  
  438.  
  439.     | the following is longjmp(), with the subtle difference that this
  440.     | thing doesn't insist in returning something non-zero... 
  441. _vfork_longjmp:
  442.     movel    sp@(4),a0    /* save area pointer */
  443.     tstl    a0@(8)        /* ensure non-zero SP */
  444.     jeq    Lbotch        /* oops! */
  445.     movel    sp@(8),d0    /* grab return value */
  446.     moveml    a0@(28),d2-d7/a2-a4/a6    /* restore non-scratch regs */
  447.     movel    a0,sp@-        /* let sigreturn */
  448.     jbsr    _sigreturn    /*   finish for us */
  449.  
  450. Lbotch:
  451.     jsr    _longjmperror
  452.     stop    #0
  453.  
  454. _vfork_resume:
  455.     pea    sp@        | pass the sp containing the return address
  456.     bsr    __vfork_resume
  457.     lea    sp@(4),sp
  458.     rts
  459. ");
  460.  
  461. static int
  462. _vfork (int own_malloc, struct reg_parms rp)
  463. {
  464.   struct Process *me = (struct Process *) FindTask(0);
  465.   struct CommandLineInterface *CLI = BTOCPTR (me->pr_CLI);
  466.   u_int stack_size = CLI ? CLI->cli_DefaultStack * 4 : me->pr_StackSize;
  467.   BPTR input, output;
  468.   /* those *have* to be in registers to survive the stack deallocation */
  469.   register struct vfork_msg *vm asm ("a2");
  470.   register int omask asm ("d2");
  471.   register struct Process *child asm ("a3");
  472.   struct TagItem tags [] = {
  473.     { NP_Entry, (ULONG) launcher, },
  474.     { NP_Cli, (ULONG) (CLI ? -1 : 0), },    /* same thing we are */
  475.     { NP_Name, (ULONG) "vfork()'d process", },    /* to be overridden by execve() */
  476.     { NP_StackSize, stack_size, },        /* same size we use */
  477.     { TAG_END, 0, }
  478.   };
  479.   KPRINTF (("vfork: creating child with stacksize = $%lx[$%lx,$%lx]\n", stack_size, tags[3]));
  480.   vm = (struct vfork_msg *) kmalloc (sizeof (struct vfork_msg));
  481.   if (! vm)
  482.     {
  483.       errno = ENOMEM;
  484.       KPRINTF (("&errno = %lx, errno = %ld\n", &errno, errno));
  485.       return -1;
  486.     }
  487.  
  488.   vm->vm_msg.mn_ReplyPort = u.u_sync_mp;
  489.   vm->vm_msg.mn_Node.ln_Type = NT_MESSAGE;
  490.   vm->vm_msg.mn_Length = sizeof (struct vfork_msg);
  491.   vm->vm_pptr = me;
  492.   vm->vm_own_malloc = own_malloc;
  493.   vm->vm_regs = & rp;
  494.  
  495.   /* we have to block all signals as long as the child uses our resources.
  496.    * but since the child needs to start with the signal mask BEFORE this
  497.    * general blocking, we have to pass it the old signal mask. This is a
  498.    * way to do it */
  499.   vm->vm_rc   = 
  500.   omask      = syscall (SYS_sigsetmask, ~0);
  501.  
  502.   /* save the passed frame in our user structure, since the child will
  503.      deallocate it from the stack when it `returns' to user code */
  504.   bcopy (&rp, &u.u_vfork_frame, sizeof (rp));
  505.  
  506.   KPRINTF (("vfork: creating child with stacksize = $%lx[$%lx,$%lx]\n", stack_size, tags[3]));
  507.   child = CreateNewProc (tags);
  508.  
  509.  
  510.   if (! child)
  511.     {
  512.       /* do I have to close input/output here? Or does the startup close
  513.          them no matter whether it succeeds or not ? */
  514.       kfree (vm);
  515.       syscall (SYS_sigsetmask, omask);
  516.       errno = EPROCLIM;
  517.       KPRINTF (("&errno = %lx, errno = %ld\n", &errno, errno));
  518.       return -1;
  519.     }
  520.  
  521.   /* As soon as this message is dispatched, the child will `return' and 
  522.      deallocate the stack we're running on. So afterwards, *only* use
  523.      register variables and then longjmp () back.
  524.      Since we don't have a stack until after the longjmp(), temporarily
  525.      switch to our mini-stack */
  526.   set_sp ((u_int) &u.u_mini_stack[sizeof (u.u_mini_stack) / sizeof (long)]);
  527.  
  528.   vm->vm_self = child;
  529.   PutMsg (& child->pr_MsgPort, (struct Message *) vm);
  530.   /* wait until the child does execve() or _exit() */
  531.   WaitPort (u.u_sync_mp);
  532.   GetMsg (u.u_sync_mp);
  533.   syscall (SYS_sigsetmask, omask);
  534.  
  535.   if (vm->vm_rc)
  536.     {
  537.       errno = (int) vm->vm_rc;
  538.       KPRINTF (("&errno = %lx, errno = %ld\n", &errno, errno));
  539.       child = (struct Process *) -1;
  540.     }
  541.       
  542.   /* this is the parent return, so we pass the id of the new child */
  543.   kfree (vm);
  544.   /* could use longjmp() here, but since we already *have* the local one.. */
  545.   vfork_longjmp (u.u_vfork_frame, (int) child);
  546. }
  547.  
  548.   
  549. ruadd(ru, ru2)
  550.     register struct rusage *ru, *ru2;
  551. {
  552.     register long *ip, *ip2;
  553.     register int i;
  554.  
  555.     timevaladd(&ru->ru_utime, &ru2->ru_utime);
  556.     timevaladd(&ru->ru_stime, &ru2->ru_stime);
  557.     if (ru->ru_maxrss < ru2->ru_maxrss)
  558.         ru->ru_maxrss = ru2->ru_maxrss;
  559.     ip = &ru->ru_first; ip2 = &ru2->ru_first;
  560.     for (i = &ru->ru_last - &ru->ru_first; i > 0; i--)
  561.         *ip++ += *ip2++;
  562. }
  563.  
  564.  
  565. /* This function is in desperate need of redesign !!!! */
  566.  
  567. int
  568. wait4 (int pid, int *status, int options, struct rusage *rusage)
  569. {
  570.   struct Process * me = (struct Process *) FindTask (0);
  571.   struct user * mu = (struct user *) me->pr_Task.tc_TrapData;
  572.   int omask;
  573.  
  574.   for (;;)
  575.     {
  576.       int err = 0, omask;
  577.       struct death_msg *dm, *ndm;
  578.       int got_node;
  579.  
  580.       got_node = 0;
  581.       Forbid ();
  582.       
  583.       for (dm  = (struct death_msg *) mu->p_zombies.mlh_Head;
  584.          ndm = (struct death_msg *) dm->dm_node.mln_Succ;
  585.          dm  = ndm)
  586.       if (pid == -1 ||
  587.           (pid == 0 && dm->dm_pgrp == mu->p_pgrp) ||
  588.         (pid < -1 && dm->dm_pgrp == - pid) ||
  589.         (pid == (int) dm->dm_child))
  590.       {
  591.         got_node = 1;
  592.         Remove ((struct Node *) dm);
  593.         break;
  594.       }
  595.  
  596.       if (!got_node && !mu->p_cptr)
  597.     err = ECHILD;
  598.  
  599.       if (got_node)
  600.         {
  601.       struct Process *child;
  602.  
  603.       KPRINTF (("wait4: unlinking child $%lx\n", dm->dm_child));
  604.       ix_wakeup (dm);
  605.       Permit ();
  606.  
  607.           if (status)
  608.             *status = dm->dm_status;
  609.           if (rusage)
  610.             *rusage = dm->dm_rusage;
  611.  
  612.       child = dm->dm_child;
  613.  
  614.       kfree (dm);
  615.  
  616.           return (int) child;
  617.     }
  618.  
  619.       if (!got_node && err)
  620.     {
  621.       Permit ();
  622.       errno = err;
  623.       KPRINTF (("&errno = %lx, errno = %ld\n", &errno, errno));
  624.       return -1;
  625.     }
  626.  
  627.       if (options & WNOHANG)
  628.     {
  629.       Permit ();
  630.       return 0;
  631.     }
  632.  
  633.       KPRINTF (("wait4: waiting for SIGCHLD\n"));
  634.       ix_sleep (mu, "wait4");
  635.       if (mu->p_sig)
  636.     err = EINTR;
  637.  
  638.       Permit ();
  639.       if (CURSIG (mu))
  640.         setrun (me);
  641.     }
  642. }
  643.